package com.grant.code.controller;

import com.grant.code.utils.DialogUtils;
import javafx.application.Platform;
import javafx.concurrent.Task;
import javafx.fxml.FXML;
import javafx.fxml.FXMLLoader;
import javafx.geometry.Bounds;
import javafx.geometry.Insets;
import javafx.geometry.Pos;
import javafx.scene.Node;
import javafx.scene.Parent;
import javafx.scene.Scene;
import javafx.scene.control.*;
import javafx.scene.image.Image;
import javafx.scene.image.ImageView;
import javafx.scene.input.*;
import javafx.scene.layout.*;
import javafx.scene.paint.Color;
import javafx.scene.shape.Rectangle;
import javafx.stage.Stage;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.util.*;

/**
 * 图片控制器 - 处理图片显示和操作的所有功能
 * 包括图片加载、选择、幻灯片播放和上下文菜单等
 */
public class ImageController {

    @FXML private TilePane imageContainer;
    @FXML private Label directoryInfo;
    @FXML private Label selectionInfo;
    @FXML private Label statusBar;
    
    private File currentDirectory;
    private final List<File> selectedImages = new ArrayList<>();
    private final List<File> currentImageFiles = new ArrayList<>();
    private final List<File> clipboard = new ArrayList<>();
    
    // 键盘控制标志
    private boolean controlDown = false;
    private boolean shiftDown = false;
    
    // 图片扩展名集合
    private final Set<String> IMAGE_EXT = Set.of(".jpg", ".jpeg", ".png", ".gif", ".bmp", 
            "JPG", "JPEG", "PNG", "GIF", "BMP");
    
    private int selectedImageIndex = 0;
    
    /**
     * 默认构造函数
     */
    public ImageController() {
        // 用于JavaFX FXML注入
    }
    
    /**
     * 带参数的构造函数
     * @param imageContainer 图片容器
     * @param directoryInfo 目录信息标签
     * @param selectionInfo 选择信息标签
     * @param statusBar 状态栏
     */
    public ImageController(TilePane imageContainer, Label directoryInfo, Label selectionInfo, Label statusBar) {
        this.imageContainer = imageContainer;
        this.directoryInfo = directoryInfo;
        this.selectionInfo = selectionInfo;
        this.statusBar = statusBar;
        initialize();
    }
    
    /**
     * 初始化图片控制器
     */
    public void initialize() {
        setupDragSelection();
        setupKeyboardListeners();
    }
    
    /**
     * 设置当前目录
     * @param directory 目录文件
     */
    public void setCurrentDirectory(File directory) {
        currentDirectory = directory;
        updateImagePreview();
    }
    
    /**
     * 获取当前目录
     * @return 当前目录
     */
    public File getCurrentDirectory() {
        return currentDirectory;
    }
    
    /**
     * 更新图片预览
     */
    private void updateImagePreview() {
        // 清空图像容器中的所有子节点
        imageContainer.getChildren().clear();
        // 清空选中的图像列表
        selectedImages.clear();
        // 清空当前图像文件列表，以便存储新数据
        currentImageFiles.clear();

        // 列出当前目录中的所有文件，筛选出图像文件
        File[] files = currentDirectory.listFiles(file ->
                IMAGE_EXT.stream().anyMatch(ext ->
                        file.getName().toLowerCase().endsWith(ext)));

        // 如果找到文件，执行以下操作
        if (files != null) {
            // 将找到的文件添加到当前图像文件列表中
            currentImageFiles.addAll(Arrays.asList(files));
            // 遍历每个找到的文件
            for (File file : files) {
                // 创建缩略图并获取 VBox 组件
                VBox thumbnail = createThumbnail(file);
                // 将缩略图添加到图像容器中
                imageContainer.getChildren().add(thumbnail);
            }
        }
        // 更新目录信息
        updateDirectoryInfo();
        // 更新选择信息
        updateSelectionInfo();
    }
    
    /**
     * 创建缩略图
     * @param file 图片文件
     * @return 缩略图容器
     */
    private VBox createThumbnail(File file) {
        VBox container = new VBox(5);
        container.setStyle("-fx-padding: 5; -fx-background-color: transparent;");
        container.setUserData(file); // 存储文件引用，这很重要
        
        // 创建图片视图
        ImageView imageView = new ImageView();
        imageView.setFitWidth(200);
        imageView.setFitHeight(150);
        imageView.setPreserveRatio(true);
        
        // 创建堆叠面板
        StackPane stackPane = new StackPane();
        stackPane.getChildren().add(imageView);
        
        // 加载图片
        loadImageAsync(file, imageView);
        
        // 添加点击事件 - 修改这里以确保选择功能正常
        container.setOnMouseClicked(event -> {
            if (event.getButton() == MouseButton.PRIMARY) {
                if (event.isControlDown() || event.isShiftDown()) {
                    // Ctrl或Shift多选
                    toggleSelection(file, container);
                } else {
                    // 普通点击单选
                    clearSelection();
                    toggleSelection(file, container);
                }
                updateSelectionInfo();
                
                // 双击处理
                if (event.getClickCount() == 2) {
                    startSlideShow(file);
                }
            }
        });
        
        // 添加右键菜单
        ContextMenu contextMenu = createImageContextMenu(file);
        container.setOnContextMenuRequested(event -> {
            // 确保右键点击的图片被选中
            if (!selectedImages.contains(file)) {
                clearSelection();
                toggleSelection(file, container);
            }
            contextMenu.show(container, event.getScreenX(), event.getScreenY());
            event.consume();
        });
        
        // 添加鼠标悬停效果
        container.setOnMouseEntered(e -> {
            if (!selectedImages.contains(file)) {
                container.setStyle("-fx-padding: 5; -fx-background-color: rgba(0, 0, 255, 0.1);");
            }
        });
        
        container.setOnMouseExited(e -> {
            if (!selectedImages.contains(file)) {
                container.setStyle("-fx-padding: 5; -fx-background-color: transparent;");
            }
        });
        
        container.getChildren().add(stackPane);
        
        // 添加文件名标签
        Label nameLabel = new Label(file.getName());
        nameLabel.setWrapText(true);
        nameLabel.setMaxWidth(200);
        nameLabel.setStyle("-fx-font-size: 12px; -fx-text-fill: #2c3e50;");
        container.getChildren().add(nameLabel);
        
        return container;
    }
    
    /**
     * 为图片创建上下文菜单
     * @param file 图片文件
     * @return 上下文菜单
     */
    private ContextMenu createImageContextMenu(File file) {
        ContextMenu contextMenu = new ContextMenu();
        
        MenuItem openItem = new MenuItem("在系统默认程序中打开");
        openItem.setOnAction(e -> {
            try {
                // 使用ProcessBuilder打开系统默认程序
                String os = System.getProperty("os.name").toLowerCase();
                ProcessBuilder builder = null;
                
                if (os.contains("win")) {
                    // Windows系统
                    builder = new ProcessBuilder("cmd", "/c", "start", "", file.getAbsolutePath());
                } else if (os.contains("mac")) {
                    // macOS系统
                    builder = new ProcessBuilder("open", file.getAbsolutePath());
                } else if (os.contains("nix") || os.contains("nux")) {
                    // Linux系统
                    builder = new ProcessBuilder("xdg-open", file.getAbsolutePath());
                }
                
                if (builder != null) {
                    builder.start();
                    statusBar.setText("正在使用系统默认程序打开图片: " + file.getName());
                } else {
                    showAlert(Alert.AlertType.ERROR, "错误", "无法打开文件", 
                             "当前系统不支持使用默认应用打开文件");
                }
            } catch (IOException ex) {
                showAlert(Alert.AlertType.ERROR, "错误", "无法打开文件", 
                         "打开文件时发生错误: " + ex.getMessage());
            }
        });
        
        MenuItem renameItem = new MenuItem("重命名");
        renameItem.setAccelerator(new KeyCodeCombination(KeyCode.F2));
        renameItem.setOnAction(e -> handleRename(file));

        MenuItem deleteItem = new MenuItem("删除");
        deleteItem.setAccelerator(new KeyCodeCombination(KeyCode.DELETE));
        deleteItem.setOnAction(e -> handleDelete(file));

        MenuItem copyItem = new MenuItem("复制");
        copyItem.setAccelerator(new KeyCodeCombination(KeyCode.C, KeyCombination.CONTROL_DOWN));
        copyItem.setOnAction(e -> handleCopy());

        MenuItem pasteItem = new MenuItem("粘贴");
        pasteItem.setAccelerator(new KeyCodeCombination(KeyCode.V, KeyCombination.CONTROL_DOWN));
        pasteItem.setOnAction(e -> handlePaste());

        MenuItem slideShowItem = new MenuItem("幻灯片播放");
        slideShowItem.setAccelerator(new KeyCodeCombination(KeyCode.F5));
        slideShowItem.setOnAction(e -> startSlideShow(file));
        
        contextMenu.getItems().addAll(openItem, renameItem, deleteItem, copyItem, pasteItem, slideShowItem);
        return contextMenu;
    }
    
    /**
     * 异步加载图片
     * @param file 图片文件
     * @param imageView 图片视图
     */
    private void loadImageAsync(File file, ImageView imageView) {
        if (file == null || !file.exists()) {
            // 加载默认占位图
            imageView.setImage(new Image(getClass().getResource("/images/image-placeholder.png").toExternalForm()));
            return;
        }

        Task<Image> loadImageTask = new Task<>() {
            @Override
            protected Image call() {
                try {
                    return new Image(file.toURI().toString());
                } catch (Exception e) {
                    e.printStackTrace();
                    return new Image(getClass().getResource("/images/image-placeholder.png").toExternalForm());
                }
            }
        };

        loadImageTask.setOnSucceeded(event -> {
            imageView.setImage(loadImageTask.getValue());
        });

        loadImageTask.setOnFailed(event -> {
            imageView.setImage(new Image(getClass().getResource("/images/image-placeholder.png").toExternalForm()));
        });

        // 在后台线程执行图片加载任务
        Thread thread = new Thread(loadImageTask);
        thread.setDaemon(true);
        thread.start();
    }
    
    /**
     * 切换图片选择状态
     * @param file 图片文件
     * @param container 缩略图容器
     */
    private void toggleSelection(File file, VBox container) {
        if (selectedImages.contains(file)) {
            selectedImages.remove(file);
            container.setStyle("-fx-padding: 5; -fx-background-color: transparent;");
        } else {
            if (!isMultiSelect()) {
                clearSelection();
            }
            selectedImages.add(file);
            container.setStyle("-fx-padding: 5; -fx-background-color: rgba(173, 216, 230, 0.5);"); // 使用淡蓝色背景
        }
        updateSelectionInfo();
    }
    
    /**
     * 判断是否为多选模式
     * @return 是否为多选模式
     */
    private boolean isMultiSelect() {
        return controlDown || shiftDown;
    }
    
    /**
     * 清除所有选择
     */
    private void clearSelection() {
        selectedImages.clear();
        // 清除所有缩略图的选择状态
        for (Node node : imageContainer.getChildren()) {
            if (node instanceof VBox) {
                VBox container = (VBox) node;
                container.setStyle("-fx-padding: 5; -fx-background-color: transparent;");
            }
        }
        updateSelectionInfo();
    }
    
    /**
     * 更新目录信息
     */
    private void updateDirectoryInfo() {
        // 计算当前目录中所有文件的总大小
        long totalSize = Arrays.stream(Objects.requireNonNull(currentDirectory.listFiles()))
                .filter(f -> !f.isDirectory())
                .mapToLong(File::length)
                .sum();
        // 获取图像容器中子节点的数量，即当前显示的图片数量
        int count = imageContainer.getChildren().size();
        // 更新目录信息的文本
        directoryInfo.setText(String.format("当前目录：%s (%d 张图片，总大小：%.2f MB)",
                currentDirectory.getName(), count, totalSize / (1024.0 * 1024.0)));
    }
    
    /**
     * 更新选择信息
     */
    private void updateSelectionInfo() {
        selectionInfo.setText("已选择：" + selectedImages.size() + " 张图片");
    }
    
    /**
     * 设置键盘监听器
     */
    private void setupKeyboardListeners() {
        // 等待 Scene 初始化完成后再添加键盘事件监听
        imageContainer.sceneProperty().addListener((obs, oldScene, newScene) -> {
            if (newScene != null) {
                // 添加键盘事件监听
                newScene.setOnKeyPressed(event -> {
                    if (event.getCode() == KeyCode.CONTROL) {
                        controlDown = true;
                    } else if (event.getCode() == KeyCode.SHIFT) {
                        shiftDown = true;
                    }
                    
                    // 添加其他快捷键处理
                    switch (event.getCode()) {
                        case DELETE:
                            handleDelete();
                            event.consume();
                            break;
                        case F2:
                            handleRename();
                            event.consume();
                            break;
                        case F5:
                            startSlideShow();
                            event.consume();
                            break;
                    }
                    
                    // 组合快捷键
                    if (event.isControlDown()) {
                        switch (event.getCode()) {
                            case C:
                                handleSystemCopy();
                                event.consume();
                                break;
                            case V:
                                handleSystemPaste();
                                event.consume();
                                break;
                        }
                    }
                });

                newScene.setOnKeyReleased(event -> {
                    if (event.getCode() == KeyCode.CONTROL) {
                        controlDown = false;
                    } else if (event.getCode() == KeyCode.SHIFT) {
                        shiftDown = false;
                    }
                });
            }
        });
    }
    
    /**
     * 设置拖拽选择功能--------修改！
     */
    private void setupDragSelection() {
        // 使用普通double变量替代Point2D
        final double[] dragStartPos = new double[2]; // [0]为X, [1]为Y
        final Rectangle selectionRect = new Rectangle();
        selectionRect.setFill(Color.rgb(52, 152, 219, 0.2));
        selectionRect.setStroke(Color.rgb(41, 128, 185));
        selectionRect.setStrokeWidth(2);
        selectionRect.setVisible(false);

        StackPane selectionContainer = new StackPane(selectionRect);
        selectionContainer.setMouseTransparent(true);

        // 获取父容器前增加校验
        Pane parentContainer = (Pane) imageContainer.getParent();
        if (parentContainer != null) {
            parentContainer.getChildren().add(selectionContainer);
        } else {
            // 延迟到布局完成后再添加（通过监听场景图变化）
            imageContainer.sceneProperty().addListener((obs, oldVal, newScene) -> {
                if (newScene != null) {
                    Pane sceneParent = (Pane) imageContainer.getParent();
                    if (sceneParent != null) {
                        sceneParent.getChildren().add(selectionContainer);
                    }
                }
            });
        }

        imageContainer.setOnMousePressed(e -> {
            if (e.getButton() == MouseButton.PRIMARY && !e.isControlDown() && !e.isShiftDown()) {
                // 使用数组存储起始位置
                dragStartPos[0] = e.getSceneX();
                dragStartPos[1] = e.getSceneY();
                selectionRect.setVisible(true);
                selectionRect.setX(dragStartPos[0]);
                selectionRect.setY(dragStartPos[1]);
                selectionRect.setWidth(0);
                selectionRect.setHeight(0);

                // 如果不按Ctrl或Shift，清除当前选择
                clearSelection();
            }
        });

        imageContainer.setOnMouseDragged(e -> {
            if (e.getButton() == MouseButton.PRIMARY && selectionRect.isVisible()) {
                double currentX = e.getSceneX();
                double currentY = e.getSceneY();

                double x = Math.min(dragStartPos[0], currentX);
                double y = Math.min(dragStartPos[1], currentY);
                double width = Math.abs(currentX - dragStartPos[0]);
                double height = Math.abs(currentY - dragStartPos[1]);

                selectionRect.setX(x);
                selectionRect.setY(y);
                selectionRect.setWidth(width);
                selectionRect.setHeight(height);

                // 检查相交的缩略图
                imageContainer.getChildren().forEach(node -> {
                    if (node instanceof VBox) {
                        VBox thumbnail = (VBox) node;
                        File file = (File) thumbnail.getUserData();

                        if (file != null) {
                            Bounds bounds = thumbnail.localToScene(thumbnail.getBoundsInLocal());

                            if (bounds.intersects(x, y, width, height)) {
                                if (!selectedImages.contains(file)) {
                                    toggleSelection(file, thumbnail);
                                }
                            }
                        }
                    }
                });

                updateSelectionInfo();
            }
        });

        imageContainer.setOnMouseReleased(e -> {
            if (e.getButton() == MouseButton.PRIMARY) {
                selectionRect.setVisible(false);
            }
        });
    }

//    /**
//     * 设置拖拽选择功能 - 支持鼠标左键框选
//     */
//    private void setupDragSelection() {
//        // 使用普通double变量替代Point2D
//        final double[] dragStartPos = new double[2]; // [0]为X, [1]为Y
//        final Rectangle selectionRect = new Rectangle();
//        selectionRect.setFill(Color.rgb(52, 152, 219, 0.2));
//        selectionRect.setStroke(Color.rgb(41, 128, 185));
//        selectionRect.setStrokeWidth(2);
//        selectionRect.setVisible(false);
//
//        // 用于存储框选过程中已处理的缩略图，避免重复处理
//        final Set<VBox> processedThumbnails = new HashSet<>();
//
//        // 用于区分单击和拖拽的标志和阈值
//        final boolean[] isDragging = new boolean[1]; // 是否处于拖拽状态
//        final double dragThreshold = 5.0; // 拖拽阈值，移动超过这个距离才被视为拖拽
//
//        StackPane selectionContainer = new StackPane(selectionRect);
//        selectionContainer.setMouseTransparent(true);
//
//        // 获取父容器前增加校验
//        Pane parentContainer = (Pane) imageContainer.getParent();
//        if (parentContainer != null) {
//            parentContainer.getChildren().add(selectionContainer);
//        } else {
//            // 延迟到布局完成后再添加（通过监听场景图变化）
//            imageContainer.sceneProperty().addListener((obs, oldVal, newScene) -> {
//                if (newScene != null) {
//                    Pane sceneParent = (Pane) imageContainer.getParent();
//                    if (sceneParent != null) {
//                        sceneParent.getChildren().add(selectionContainer);
//                    }
//                }
//            });
//        }
//
//        imageContainer.setOnMousePressed(e -> {
//            // 检测左键按下
//            if (e.getButton() == MouseButton.PRIMARY) {
//                // 使用数组存储起始位置
//                dragStartPos[0] = e.getSceneX();
//                dragStartPos[1] = e.getSceneY();
//
//                // 初始状态不显示选择框，等确认是拖拽后再显示
//                selectionRect.setVisible(false);
//                selectionRect.setX(dragStartPos[0]);
//                selectionRect.setY(dragStartPos[1]);
//                selectionRect.setWidth(0);
//                selectionRect.setHeight(0);
//
//                // 清空处理过的缩略图集合
//                processedThumbnails.clear();
//
//                // 重置拖拽状态
//                isDragging[0] = false;
//
//                // 如果不按Ctrl或Shift，清除当前选择
//                if (!e.isControlDown() && !e.isShiftDown()) {
//                    clearSelection();
//                }
//            }
//        });
//
//        imageContainer.setOnMouseDragged(e -> {
//            // 检测左键拖拽
//            if (e.getButton() == MouseButton.PRIMARY) {
//                double currentX = e.getSceneX();
//                double currentY = e.getSceneY();
//
//                // 计算拖拽距离，判断是否超过阈值
//                double dragDistance = Math.sqrt(
//                        Math.pow(currentX - dragStartPos[0], 2) +
//                                Math.pow(currentY - dragStartPos[1], 2)
//                );
//
//                // 如果超过阈值，认为是拖拽开始
//                if (dragDistance > dragThreshold) {
//                    isDragging[0] = true;
//                    selectionRect.setVisible(true);
//                }
//
//                if (isDragging[0]) {
//                    double x = Math.min(dragStartPos[0], currentX);
//                    double y = Math.min(dragStartPos[1], currentY);
//                    double width = Math.abs(currentX - dragStartPos[0]);
//                    double height = Math.abs(currentY - dragStartPos[1]);
//
//                    selectionRect.setX(x);
//                    selectionRect.setY(y);
//                    selectionRect.setWidth(width);
//                    selectionRect.setHeight(height);
//
//                    // 检查相交的缩略图
//                    imageContainer.getChildren().forEach(node -> {
//                        if (node instanceof VBox) {
//                            VBox thumbnail = (VBox) node;
//                            File file = (File) thumbnail.getUserData();
//
//                            if (file != null) {
//                                Bounds bounds = thumbnail.localToScene(thumbnail.getBoundsInLocal());
//
//                                if (bounds.intersects(x, y, width, height)) {
//                                    // 避免重复处理同一个缩略图
//                                    if (!processedThumbnails.contains(thumbnail) && !selectedImages.contains(file)) {
//                                        toggleSelection(file, thumbnail);
//                                        processedThumbnails.add(thumbnail);
//                                    }
//                                }
//                            }
//                        }
//                    });
//
//                    updateSelectionInfo();
//                }
//            }
//        });
//
//        imageContainer.setOnMouseReleased(e -> {
//            // 检测左键释放
//            if (e.getButton() == MouseButton.PRIMARY) {
//                if (isDragging[0]) {
//                    selectionRect.setVisible(false);
//                    // 可以在这里添加选择完成后的操作
//                } else {
//                    // 如果不是拖拽，则是单击，处理单击选择逻辑
//                    // 注意：这里假设已经有单击处理逻辑，如handleImageClick方法
//                    // 如果没有对应的方法，需要添加
//                }
//            }
//        });
//    }

    /**
     * 处理重命名操作
     */
    @FXML
//    public void handleRename() {
//        if (selectedImages.isEmpty()) {
//            DialogUtils.showErrorDialog("错误", "没有选中的图片可供重命名");
//            return;
//        }
//        handleRename(selectedImages.get(0)); // 默认处理第一个选中的文件
//    }
/**
 * 处理重命名操作，支持单选和多选
 */
    public void handleRename() {
        // 获取选中的图片文件
        List<File> selectedFiles = selectedImages; // 需要实现此方法获取选中的图片

        if (selectedFiles == null || selectedFiles.isEmpty()) {
            DialogUtils.showErrorDialog("错误", "请选择要重命名的图片");
            return;
        }

        if (selectedFiles.size() > 1 || isMultiSelect()) {
            // 多选模式 - 批量重命名
            handleBatchRename(selectedFiles);
        } else {
            // 单选模式 - 单个重命名
            handleSingleRename(selectedFiles.get(0));
        }
    }

    /**
     * 处理重命名操作
     * @param file 要重命名的文件
     */
    public void handleRename(File file) {
        if (file == null) {
            DialogUtils.showErrorDialog("错误", "请选择要重命名的图片");
            return;
        }

        TextInputDialog dialog = new TextInputDialog(file.getName());
        dialog.setTitle("重命名图片");
        dialog.setHeaderText("请输入新的图片名称");
        dialog.setContentText("新名称:");

        Optional<String> result = dialog.showAndWait();
        result.ifPresent(newName -> {
            String extension = "";
            int lastDotIndex = file.getName().lastIndexOf('.');
            if (lastDotIndex > 0) {
                extension = file.getName().substring(lastDotIndex);
            }
            File newFile = new File(file.getParent(), newName + extension);
            if (newFile.exists()) {
                DialogUtils.showErrorDialog("错误", "文件已存在");
                return;
            }

            if (file.renameTo(newFile)) {
                DialogUtils.showSuccessDialog("成功", "图片重命名成功");
                updateImagePreview();
                updateSelectionInfo();
                updateDirectoryInfo();
            } else {
                DialogUtils.showErrorDialog("错误", "图片重命名失败");
            }
        });
    }
    /**
     * 处理单个图片的重命名
     * @param file 要重命名的文件
     */
    private void handleSingleRename(File file) {
        // 提取文件名(不含扩展名)作为默认值
        String currentName = file.getName();
        String nameWithoutExtension = currentName.substring(0, currentName.lastIndexOf('.'));

        TextInputDialog dialog = new TextInputDialog(nameWithoutExtension);
        dialog.setTitle("重命名图片");
        dialog.setHeaderText("请输入新的图片名称");
        dialog.setContentText("新名称:");

        Optional<String> result = dialog.showAndWait();
        result.ifPresent(newName -> {
            String extension = "";
            int lastDotIndex = file.getName().lastIndexOf('.');
            if (lastDotIndex > 0) {
                extension = file.getName().substring(lastDotIndex);
            }
            File newFile = new File(file.getParent(), newName + extension);
            if (newFile.exists()) {
                DialogUtils.showErrorDialog("错误", "文件已存在");
                return;
            }

            if (file.renameTo(newFile)) {
                DialogUtils.showSuccessDialog("成功", "图片重命名成功");
                updateImagePreview();
                updateSelectionInfo();
                updateDirectoryInfo();
            } else {
                DialogUtils.showErrorDialog("错误", "图片重命名失败");
            }
        });
    }

    /**
     * 处理批量图片重命名
     * @param files 要重命名的文件列表
     */
    private void handleBatchRename(List<File> files) {
        // 创建一个自定义对话框用于批量重命名
        Dialog<Map<String, Object>> dialog = new Dialog<>();
        dialog.setTitle("批量重命名图片");
        dialog.setHeaderText("请输入批量重命名参数 (共选中" + files.size() + "张图片)");

        // 设置对话框按钮
        ButtonType confirmButtonType = new ButtonType("确定", ButtonBar.ButtonData.OK_DONE);
        dialog.getDialogPane().getButtonTypes().addAll(confirmButtonType, ButtonType.CANCEL);

        // 创建表单
        GridPane grid = new GridPane();
        grid.setHgap(10);
        grid.setVgap(10);
        grid.setPadding(new Insets(20, 150, 10, 10));

        TextField prefixField = new TextField("NewName");
        TextField startNumberField = new TextField("1");
        ComboBox<String> digitCountBox = new ComboBox<>();
        digitCountBox.getItems().addAll("1", "2", "3", "4", "5", "6");
        digitCountBox.setValue("4");

        grid.add(new Label("名称前缀:"), 0, 0);
        grid.add(prefixField, 1, 0);
        grid.add(new Label("起始编号:"), 0, 1);
        grid.add(startNumberField, 1, 1);
        grid.add(new Label("编号位数:"), 0, 2);
        grid.add(digitCountBox, 1, 2);

        dialog.getDialogPane().setContent(grid);

        // 请求输入焦点
        Platform.runLater(() -> prefixField.requestFocus());

        // 转换结果
        dialog.setResultConverter(dialogButton -> {
            if (dialogButton == confirmButtonType) {
                Map<String, Object> params = new HashMap<>();
                try {
                    params.put("prefix", prefixField.getText());
                    params.put("startNumber", Integer.parseInt(startNumberField.getText()));
                    params.put("digitCount", Integer.parseInt(digitCountBox.getValue()));
                    return params;
                } catch (NumberFormatException e) {
                    return null;
                }
            }
            return null;
        });

        Optional<Map<String, Object>> result = dialog.showAndWait();
        if (result.isPresent()) {
            Map<String, Object> params = result.get();
            String prefix = (String) params.get("prefix");
            int startNumber = (Integer) params.get("startNumber");
            int digitCount = (Integer) params.get("digitCount");

            executeBatchRename(files, prefix, startNumber, digitCount);
        }
    }

    /**
     * 执行批量重命名
     * @param files 文件列表
     * @param prefix 名称前缀
     * @param startNumber 起始编号
     * @param digitCount 编号位数
     */
    private void executeBatchRename(List<File> files, String prefix, int startNumber, int digitCount) {
        int currentNumber = startNumber;
        int successCount = 0;
        int failCount = 0;
        List<String> failedFiles = new ArrayList<>();

        // 首先检查文件是否已存在，避免重命名过程中出现冲突
        boolean hasConflict = false;
        for (int i = 0; i < files.size(); i++) {
            File file = files.get(i);
            String extension = "";
            int lastDotIndex = file.getName().lastIndexOf('.');
            if (lastDotIndex > 0) {
                extension = file.getName().substring(lastDotIndex);
            }

            String format = "%s%0" + digitCount + "d%s";
            String newFilename = String.format(format, prefix, currentNumber + i, extension);
            File newFile = new File(file.getParent(), newFilename);

            if (newFile.exists() && !newFile.equals(file)) {
                hasConflict = true;
                failedFiles.add(newFilename);
            }
        }

        if (hasConflict) {
            DialogUtils.showErrorDialog("错误", "以下文件已存在，无法完成重命名:\n" +
                    String.join("\n", failedFiles.subList(0, Math.min(5, failedFiles.size()))) +
                    (failedFiles.size() > 5 ? "\n...等" + failedFiles.size() + "个文件" : ""));
            return;
        }

        // 执行重命名
        for (File file : files) {
            String extension = "";
            int lastDotIndex = file.getName().lastIndexOf('.');
            if (lastDotIndex > 0) {
                extension = file.getName().substring(lastDotIndex);
            }

            String format = "%s%0" + digitCount + "d%s";
            String newFilename = String.format(format, prefix, currentNumber, extension);
            File newFile = new File(file.getParent(), newFilename);

            if (file.renameTo(newFile)) {
                successCount++;
            } else {
                failCount++;
                failedFiles.add(file.getName());
            }

            currentNumber++;
        }

        // 更新UI
        updateImagePreview();
        updateSelectionInfo();
        updateDirectoryInfo();

        // 显示结果
        if (failCount > 0) {
            DialogUtils.showErrorDialog("批量重命名结果",
                    "共处理" + files.size() + "个文件: " + successCount + "个成功, " + failCount + "个失败");
        } else {
            DialogUtils.showSuccessDialog("批量重命名结果",
                    "共重命名" + successCount + "个文件，全部成功！");
        }
    }

    /**
     * 处理删除操作
     */
    @FXML
    public void handleDelete() {
        if (selectedImages.isEmpty()) {
            DialogUtils.showErrorDialog("错误", "没有选中的图片可供删除");
            return;
        }

        Alert alert = new Alert(Alert.AlertType.CONFIRMATION);
        alert.setTitle("确认删除");
        alert.setHeaderText("确认删除选中的图片吗？");
        alert.setContentText("此操作无法撤销，请确认是否继续。");

        Optional<ButtonType> result = alert.showAndWait();
        if (result.isPresent() && result.get() == ButtonType.OK) {
            boolean anySuccess = false;
            for (File file : new ArrayList<>(selectedImages)) {
                if (file.delete()) {
                    anySuccess = true;
                }
            }
            
            if (anySuccess) {
                DialogUtils.showSuccessDialog("成功", "图片删除成功");
                updateImagePreview();
            } else {
                DialogUtils.showErrorDialog("错误", "图片删除失败");
            }
        }
    }
    
    /**
     * 处理删除操作
     * @param file 要删除的文件
     */
    public void handleDelete(File file) {
        // 检查文件是否为 null 或不存在
        if (file == null || !file.exists()) {
            // 显示错误对话框
            DialogUtils.showErrorDialog("错误", "无效的文件");
            return;
        }

        // 显示确认对话框，询问用户是否确定删除
        boolean confirm = DialogUtils.showConfirmDialog("确认删除",
                "确定要删除选中的图片吗？");

        // 如果用户确认删除，并且文件成功删除
        if (confirm && file.delete()) {
            // 从选中的图片列表中移除该文件
            selectedImages.remove(file);
            // 更新图像预览
            updateImagePreview();
        }
    }
    
    /**
     * 处理复制操作
     */
    @FXML
    public void handleCopy() {
        // 清空剪贴板
        clipboard.clear();
        // 将选中的图片文件添加到剪贴板
        clipboard.addAll(selectedImages);
        
        if (!selectedImages.isEmpty()) {
            statusBar.setText("已复制 " + selectedImages.size() + " 个文件到剪贴板");
        }
    }
    
    /**
     * 处理系统级复制操作
     */
    private void handleSystemCopy() {
        Clipboard clipboard = Clipboard.getSystemClipboard();
        ClipboardContent content = new ClipboardContent();

        List<File> files = new ArrayList<>(selectedImages);
        content.putFiles(files);
        clipboard.setContent(content);
        
        if (!files.isEmpty()) {
            statusBar.setText("已复制 " + files.size() + " 个文件到系统剪贴板");
        }
    }
    
    /**
     * 处理粘贴操作
     */
    @FXML
    public void handlePaste() {
        // 检查剪贴板是否为空以及当前目录是否为 null
        if (clipboard.isEmpty() || currentDirectory == null) return;

        // 遍历剪贴板中的每个源文件
        clipboard.forEach(src -> {
            try {
                // 生成目标文件的唯一名称
                File dest = generateUniqueName(src);
                // 复制源文件到目标位置
                Files.copy(src.toPath(), dest.toPath());
            } catch (Exception e) {
                // 如果复制失败，显示错误对话框，提示错误信息
                DialogUtils.showErrorDialog("复制失败", e.getMessage());
            }
        });
        // 更新图像预览以显示新复制的文件
        updateImagePreview();
        statusBar.setText("已粘贴 " + clipboard.size() + " 个文件");
    }
    
    /**
     * 处理系统级粘贴操作
     */
    private void handleSystemPaste() {
        Clipboard clipboard = Clipboard.getSystemClipboard();
        if (clipboard.hasFiles() && currentDirectory != null) {
            List<File> files = clipboard.getFiles();
            files.forEach(file -> {
                try {
                    File dest = generateUniqueName(file);
                    Files.copy(file.toPath(), dest.toPath());
                } catch (Exception e) {
                    DialogUtils.showErrorDialog("粘贴失败", e.getMessage());
                }
            });
            updateImagePreview();
            statusBar.setText("已粘贴 " + files.size() + " 个文件");
        }
    }
    
    /**
     * 生成唯一文件名
     * @param src 源文件
     * @return 目标文件
     */
    private File generateUniqueName(File src) {
        // 获取文件的基本名称（去掉扩展名）
        String baseName = src.getName().split("\\.")[0];
        // 获取文件的扩展名
        String extension = src.getName().contains(".") ?
                src.getName().substring(src.getName().lastIndexOf(".")) : "";

        // 创建一个新的目标文件，初始为源文件的名称
        File dest = new File(currentDirectory, src.getName());
        int counter = 1;
        // 如果目标文件已存在，继续生成新的文件名
        while (dest.exists()) {
            dest = new File(currentDirectory,
                    baseName + "_" + counter + extension);
            counter++;
        }
        return dest;
    }
    
    /**
     * 启动幻灯片播放
     */
    @FXML
    public void startSlideShow() {
        if (currentImageFiles.isEmpty()) {
            DialogUtils.showErrorDialog("错误", "当前目录没有图片可供播放");
            return;
        }
        
        if (selectedImages.isEmpty()) {
            // 使用当前目录的第一张图片
            startSlideShow(currentImageFiles.get(0));
        } else {
            // 使用第一个选中的图片
            startSlideShow(selectedImages.get(0));
        }
    }

    /**
     * 使用所有图片启动幻灯片播放
     * @param startFile 起始图片文件
     */
    public void startSlideShowWithAllImages(File startFile) {
        try {
            FXMLLoader loader = new FXMLLoader(getClass().getResource("/fxml/imageViewer.fxml"));
            Parent root = loader.load();

            ImagerViewerController controller = loader.getController();
            // 使用所有图片
            controller.setImageList(new ArrayList<>(currentImageFiles),
                    currentImageFiles.indexOf(startFile));

            Stage stage = new Stage();
            stage.setScene(new Scene(root));
            stage.setTitle("图片查看器");
            stage.show();
        } catch (IOException e) {
            DialogUtils.showErrorDialog("系统错误", "无法加载图片查看器：" + e.getMessage());
        }
    }


    /**
     * 使用选中的图片启动幻灯片播放
     * @param selectedFiles 选中的图片列表
     */
    public void startSlideShowWithSelectedImages(List<File> selectedFiles) {
        if (selectedFiles == null || selectedFiles.isEmpty()) return;

        try {
            FXMLLoader loader = new FXMLLoader(getClass().getResource("/fxml/imageViewer.fxml"));
            Parent root = loader.load();

            ImagerViewerController controller = loader.getController();
            // 确保传递的是选中的图片列表，而不是所有图片
            controller.setImageList(new ArrayList<>(selectedFiles), 0);

            Stage stage = new Stage();
            stage.setScene(new Scene(root));
            stage.setTitle("图片查看器");
            stage.show();
        } catch (Exception e) {
            e.printStackTrace();
            DialogUtils.showErrorDialog("错误", "无法启动幻灯片查看器：" + e.getMessage());
        }
    }
    
    /**
     * 启动幻灯片播放
     * @param startFile 起始图片文件
     */
    public void startSlideShow(File startFile) {
        try {
            FXMLLoader loader = new FXMLLoader(getClass().getResource("/fxml/imageViewer.fxml"));
            Parent root = loader.load();

            ImagerViewerController controller = loader.getController();

            // 修改：始终使用当前预览区中的所有图片，而不仅是选择的图片
            // 这样在查看器中就可以浏览所有图片，而不只是选择的图片
            controller.setImageList(new ArrayList<>(currentImageFiles),
                    currentImageFiles.indexOf(startFile));

            Stage stage = new Stage();
            stage.setScene(new Scene(root));
            stage.setTitle("图片查看器");
            stage.show();

        } catch (IOException e) {
            DialogUtils.showErrorDialog("系统错误", "无法加载图片查看器：" + e.getMessage());
        }
    }
    
    /**
     * 显示警告或错误对话框
     * @param type 对话框类型
     * @param title 标题
     * @param header 头部文本
     * @param content 内容文本
     */
    private void showAlert(Alert.AlertType type, String title, String header, String content) {
        Alert alert = new Alert(type);
        alert.setTitle(title);
        alert.setHeaderText(header);
        alert.setContentText(content);
        alert.showAndWait();
    }
    
    /**
     * 从目录加载图片
     * @param directory 图片目录
     */
    public void loadImagesFromDirectory(File directory) {
        if (directory == null || !directory.exists() || !directory.isDirectory()) {
            return;
        }
        
        // 实现加载图片的逻辑
        // ...
        
        updateImagePreview();
    }
    
    /**
     * 获取选中图片的索引
     * @return 当前选中图片的索引
     */
    public int getSelectedImageIndex() {
        return selectedImageIndex;
    }
    
    /**
     * 获取当前目录下的所有图片文件
     * @return 图片文件列表
     */
    public List<File> getImageFiles() {
        return currentImageFiles;
    }
} 